
# addition
1 + 2


# exponents
20^(1/2)


# basic math functions
sqrt(20)


# advanced math functions
factorial(3)


# access to constants
pi

# This is a function to calculate the powers of e
exp(1)


# Plot a quick equation!
curve(10*x^2, from=0, to=2)


# Plot a parabola
curve(10*x^2, xlim = c(-2,2))


# Use ? to retrieve a description of help()
?help
# Note the lack of ()?


help(help)


# A list of common functions that we won't look at
?str

# ?c
# ?seq
# ?setwd
# ?sort
# ?dir
# ?head
# ?names
# ?summary
# ?dim
# ?range
# ?max
# ?min
# ?sum
# ?pairs
# ?plot


# Assign with the standard =

a = 4
# Use the print command to print simple and complex expressions
print(a)

# Or just evaluate the expression to standard output
a + 2

[1] 4


#Left hand assigner (original way to assign results) 
# sometimes the <- is necessary for functions originally created in S. 
# Often seen on R help forums if you Google future issues

a <- 3
a


#Right hand assigner

3 -> d
d


# Assign some variables
a = 4
b = 2

# Multiply them
a * b


# each code after a semicolon is interpreted as a line
a=4; b=2; a*b


b=2

a=3;b*a

# versus

a = 3; b *     a


# No spaces
paste("Can", "I", "go", "out", "now", "?", sep = "")

# Single space as a separator
paste("Can", "I", "go", "out", "now", "?", sep = " ")

# Triple space as a separator
paste("Can", "I", "go", "out", "now", "?", sep = "    ")


# What will be the final value of i?

i = 1
i = i + 1
i = i + 1
i = i + 1
i = i + 1
i = i + 1
i = i + 1
i


# Remind ourselves the values of a and b
a;b
# Use multiple values in an expression assigned to a variable 
result <- 5 * a + 2 * b
result

# make a calculation
result ^ pi


# Use and overwrite the current value of "result"
result <- result ^ pi

# this PERMANENTLY overwrote your old 'result' object. If this is an important value be sure to keep it safe!
result


# Don't forget that variable names ARE case-sensitive
a = 5
A = 7
b = 3
B = 15

# Output our variable values
b; B; a; A; a + A


# It doesn't matter what your variable is named, a scalar is still a single value
X <- 5
b <- 10


# character vectors
character_vector <- c('bacteria', 'virus', 'archaea')
character_vector


# numeric vectors
numeric_vector <- c(1:10)
numeric_vector


# logical vectors
logical_vector <- c(TRUE, FALSE, TRUE) # TRUE and FALSE are also know as "boolean"
logical_vector


# Integer vectors
integer_vector <- c(1L, 8L) 
# The "L" makes the numbers integers. Can be used to get your code to run faster and consume less memory. 
# A double ("numeric") vector uses 8 bytes per element. An integer vector uses only 4 bytes per element

integer_vector


# What happens if we try to include more than one type of data?
mixed_vector <- c("bacteria", 1, TRUE, NA)
mixed_vector

# Let's look at the structure of our vector
str(mixed_vector)

 chr [1:4] "bacteria" "1" "TRUE" NA


# Let's convert our mixed_vector
into_numeric <- as.numeric(mixed_vector); into_numeric

# What about our logical_vector?
as.numeric(logical_vector)

Warning message in eval(expr, envir, enclos):
"NAs introduced by coercion"


names(logical_vector) <- c("male", "elderly", "heart attack")
logical_vector


#is equivalent to 

logical_vector <- c("male" = TRUE, "elderly" = FALSE, "heart attack" = TRUE)

logical_vector


# or using a ;

logical_vector <- c("male" = TRUE, "elderly" = FALSE, "heart attack" = TRUE); logical_vector


# The number of elements in a vector is its length.
length(character_vector)

length(numeric_vector)

length(logical_vector)


# Display our character vector again
character_vector

# You can grab a specific element by its index
character_vector[3]


# Use the ":" to generate a range of indices automatically as a vector
1:10

#second and third element in the vector inclusive (varies across programming languages)
character_vector[2:3]


#you can use negative indexing to select 'everything but'
character_vector[-2]

character_vector[-c(2,3)]


# You can grab elements by their assigned "names"
logical_vector["male"]

logical_vector[c("male", "elderly")]


# What will the output be?
my_matrix <- matrix(c(...), nrow = ..., ncol = ...)

my_matrix


# Equivalent result by calling rep just once

my_matrix <- matrix(c(...), nrow = 5, ncol = 5)

my_matrix


# Make a matrix by recycling within rep() but not within the matrix() call
my_matrix <- matrix(c(rep(...)), nrow = 5, ncol = 5)

# print the matrix
my_matrix; print("version 1")


# No recycling in generating the initial vector
my_matrix <- matrix(c(rep(0, 10), rep(1,10), rep(0, 5)), nrow = 5, ncol = 5)
my_matrix; print("version 2")


# Just write out the entire vector you want to convert to matrix
my_matrix <- matrix(c(0,0,0,0,0,0,0,0,0,0,1,1,1,1,1,1,1,1,1,1,0,0,0,0,0), nrow = 5, ncol = 5)
my_matrix; print("version 3")


# We can replicate through coercion!
my_matrix <- matrix(as.numeric(c(rep(FALSE, 10), rep(TRUE,10), rep(FALSE, 5))), nrow = 5, ncol = 5)
my_matrix; print("version 4")


#This may be a good time to mention that TRUE and FALSE can be abbreviated to T and F
my_matrix <- matrix(as.numeric(c(F,F,F,F,F,F,F,F,F,F,T,T,T,T,T,T,T,T,T,T,F,F,F,F,F)), nrow = 5, ncol = 5)
my_matrix; print("version 5")


matrix(c(0,0,0,1,1,1,0,0,0,0,1,1,1,1,0,0,0,0,1,1,1,1,1,1,0), nrow = 5, ncol = 5)


...(c(rep(0, 10), rep(1,10), nrow = 5, ncol = 5))


# Define a matrix using a few different seq() calls
matrix(c(seq(...), 
         seq(3,12,3),                    # Note we don't have to name the parameters 
         rep(seq(0,1,1), 3)),            # This last call is a bit repetetive
       nrow = 4, ncol = 4, byrow = TRUE) # Notice also we are filling by row instead of by column


# Compare that to this version
matrix(c(seq(from = 2, to = 12, by = 2), 
         seq(3,12,3), 
         rep(..., 3)), # simplified 
       nrow = 4, ncol = 4, byrow = TRUE)


# Or hard-code that last section instead
matrix(c(seq(2, 12, 2), seq(3,12,3), ...), nrow = 4, ncol = 4, byrow = TRUE)


# Replace your 1s and 0s with booleans for coercion
matrix(c(seq(2, 12, 2), seq(3,12,3), rep(c(F,T), 3)), nrow = 4, ncol = 4, byrow = TRUE)


# A matrix is a 2D object. We can now check out a couple more properties - like the number of rows and columns.
my_matrix

print("structure")
...

print("rows")
...(my_matrix)

print("columns")
...(my_matrix)

print("dimensions")
...(my_matrix) # reported as rows vs columns

print("length")
...(my_matrix)


#To access a specific row or column we can still use indexing.

# Return rows 3:5 and all columns
my_matrix[...,]

# Return all rows, and column 4
my_matrix[, ...]


# How can we ask the type of object returned? 
...(my_matrix[,4])

# Look at the dimensions returned for a vector
str(my_matrix[,4])

# vs. a matrix
str(my_matrix[...])


# It is common to transpose matrices. Note that the set of ones will now be in rows rather than columns.

...


class(character_vector)
class(numeric_vector)
class(...)


# Let's make a data frame
# Recall that we can generate a vector simply using c(data1, data2, ..., dataN)

my_data_frame <- data.frame(character = c(...),
                            num = c(...),
                            log = c(TRUE, FALSE, TRUE))

## Oops! This will break the second rule of data frame club


# Let's make a data frame correctly

my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                            num = c(...),
                            log = c(TRUE, FALSE, TRUE))

my_data_frame


# What is the structure of a data frame?
...


# cast a matrix to a dataframe
new_data_frame <- ...(my_matrix)
new_data_frame


# Note that R just made up column names for us. We can provide our own vector of column names.
... <- c("col1", "col2", "col3", "col4", "col5")

#equivalent to
... <- c(paste0(rep("col",5), 1:5))
new_data_frame


# Rename our columns using specific positions
colnames(new_data_frame)[...] = c("newcol1", "newcol3", "newcol5")

# Let's check our handiwork
new_data_frame


# In contrast, our data frame with multiple data types cannot be converted into a matrix
# A matrix can only hold one data type. We could however, transform our new_data_frame back into a matrix. 
# The matrix will retain our column heading.

new_matrix <- ...(my_data_frame)
str(new_matrix)
new_matrix


# Let's look at the "num" column closer
str(new_matrix[,...])


mixed_list <- ...(character = c('bacteria', 'virus', 'archaea'), 
                   num = c(1:3), 
                   log = c(TRUE, FALSE, TRUE))

print(mixed_list)


#formatting - equivalent, but less reader friendly for longer lists
mixed_list = list(character = c('bacteria', 'virus', 'archaea'), num = c(1:10), log = c(TRUE, FALSE, TRUE))

print(mixed_list)


str(mixed_list)

str(...)


# To subset for 'virus', I first have to subset for the character element of the list. Kind of like a Russian nested doll or a present, where you have to open the outer layer to get to the next.

# Retrieve a single element directly
print("Retrieve a single element")
mixed_list...

# What kind of object is that?
print("What kind of object is it?")
str(mixed_list[[1]])

# Compare to using single []
print("Contrast to using the [] notation")
str(mixed_list[1])

# Access using a named element
print("What is returned using an elements name?")
str(mixed_list$...)


# Begin with [[]] notation and THEN index [] with the appropriate syntax 
mixed_list[[1]]...
mixed_list$character[2]

# This will fail because it returns a list!
mixed_list[1][2]


crazy_factor = ...(c("up", "down", "down", "sideways", "up"))

crazy_factor


# or
print(crazy_factor) 
# print() is needed inside iterative functions (e.g. looping) to actually print the ouput that is being generated


# Access levels of a factor directly with level()
...(crazy_factor)

# Is it a vector?
is.vector(levels(crazy_factor))


# How many levels does crazy_factor have?
...(crazy_factor)


# Cast that factor
...(crazy_factor) 

#Notice the alphabetic rearrangement! It's important to keep this in mind when looping (week 7)


# Look at the data frame with and without the stringsAsFactors call
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                            num = c(1:3), 
                            log = c(TRUE, FALSE, TRUE))

...(my_data_frame)


# All character vectors become factors
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                            num = c(1:3), 
                            log = c(TRUE, FALSE, TRUE), ...)

str(my_data_frame)


# Only columns you specify as factors will be factors
my_data_frame <- data.frame(character = ...(c('bacteria', 'virus', 'archaea')),
                            num = c(1:3), 
                            log = c(TRUE, FALSE, TRUE))

str(my_data_frame)


my_data_frame$...

#equivalent to

my_data_frame...

# Just make a list of the levels
levels(my_data_frame$character)

# How many levels are there?
nlevels(my_data_frame$character)


# Convert our factors to a numeric representation
...(my_data_frame$character)


# Set up my_data_frame again
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                            num = c(1:3), 
                            log = c(TRUE, FALSE, TRUE))

#this is okay - specify your levels explicitly rather than allowing it to choose by default
my_data_frame$character <- factor(my_data_frame$character, 
                                  ... = c('bacteria', 'virus', 'archaea'))

# Note that you could define your factor inside the data.frame()

str(my_data_frame)
#archaea, bacteria, virus
#2,3,1


# Here's an example of misspelling levels. What will happen?
factor(c("bacteria", "virus", "archaea"), levels=c("bacteria", "virus", "..."))


# Set up my_data_frame again
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                            num = c(1:3), 
                            log = c(TRUE, FALSE, TRUE))

#this is okay, what we wanted except implies a < relationship
#class is actually 'ordered' 'factor'
#Ordered factors differ from factors only in their class, 
#but methods and the model-fitting functions treat the two classes quite differently.
my_data_frame$character <- factor(my_data_frame$character, 
                                  levels = c('bacteria', 'virus', 'archaea'), 
                                  ... = TRUE)

print(my_data_frame$character)
str(my_data_frame)
#bacteria, virus, archaea
#1,2,3


# When labeling factors can go wrong
# Run again my_data_frame
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                            num = c(1:3), 
                            log = c(TRUE, FALSE, TRUE))

#factor() will decide the level order on it's OWN before applying the given labels!
my_data_frame$character <- factor(my_data_frame$character, 
                                  ... = c('label_1', 'label_2', '...'))

print(my_data_frame$character)
str(my_data_frame)
#bacteria, virus, archaea
#BUT named levels above, therefore
#bacteria = label_2, virus = label_3, archaea = label_1
#2,3,1
#BUT data frame changed to:
#virus, archaea, bacteria


# Labeling factors correctly
# Run again my_data_frame
my_data_frame <- data.frame(character = c('bacteria', 'virus', 'archaea'), 
                 num = c(1:3), 
                 log = c(TRUE, FALSE, TRUE))

# You need to supply factor() with the levels and labels if you want them turn our how you envision it
my_data_frame$character <- factor(my_data_frame$character, 
                                  ... = c('bacteria', 'virus', 'archaea'), # explicitly order your levels!
                                  ... = c('bacteria_label', 'virus_label', 'archaea_label')) # names the levels

#bacteria, virus, archaea
#1,2,3
print(my_data_frame$character)
str(my_data_frame)


my_data_frame

# or outside of Jupyter use the View() function for a pop-up pane that looks a bit like an excel sheet 
# (more familiar to our eyes)

print(my_data_frame)


# Multiply the entire data frame
my_data_frame * ...

# Multiple just a single column
my_data_frame$... * 4

# Slice a column and multiply
my_data_frame... * 4


# Make a dataframe with 3 columns (Site1, Site2, Site3) and 4 rows (geneA, geneB, geneC, geneD)
counts <- data.frame(Site1 = c(geneA = 2, geneB = 4, geneC = 12, geneD = 8),
                     Site2 = c(geneA = 15, geneB = 18, geneC = 27, geneD = 28),
                     Site3 = c(geneA = 10, geneB = 7, geneC = 13, geneD = 15))
                     
counts

#?apply

# This won't work because x is lower case
#apply(x = counts, MARGIN = 1, FUN = sum)
print("apply() with sum across rows")
apply(X = counts, MARGIN = 1, FUN = ...)

print("apply() returns a numeric vector")
str(...)

class(...)


# Using apply() across rows
apply(counts, MARGIN = 1, mean)

apply(counts, MARGIN = 1, sd)

apply(counts, MARGIN = 1, median)

apply(counts, MARGIN = 1, ...)


apply(counts, MARGIN = 1, sum)

#equivalent to

apply(counts, MARGIN = 1, ...)


apply(counts, 
      MARGIN = 1, 
      function(x) (...))


my_array <- array(data = 1:10, dim = c(2,3,5))

# Note that we need to print the array in order to make it more human-readable in Jupyter notebooks
print(my_array)

# What are the properties of my_array?
print("structure")
str(my_array)

print("dimensions")
dim(my_array)


# You can make matrices with characters too!
# This is a constant in R for upper case letters
LETTERS

print(array(data = LETTERS, dim=c(3,4,2)))


# This arrangement makes it more clear how we would subset the number 7 out of array 5.
my_array[1, 2, 5]


# A 2D array is just a matrix. Unless you specify a 3rd dimension.

twoD_array <- array(data = 1:10, dim = c(2,3))
print(twoD_array)


#equivalent to

twoD_array2 <- array(data = 1:10, dim = c(2,3,1))
print(twoD_array)


# Check the difference between these two arrays
all.equal(twoD_array, twoD_array2)
class(twoD_array)
class(twoD_array2)


# So you can do math... on an array.
print("my_array")
print(my_array)

print("Multiply all elements by 4")
print(my_array * 4)

print("Multiple a single element by 4")
print(my_array[1, 2, 5] * 4) # why do we have three indices for this array?

Data type	Description	Example
character	Can be single or multiple characters (strings) of letters and symbols. Assigned using double `'` or `"`	a#c&E
integer	Whole number values, either positive or negative	1
double	Any number that is not an integer, AKA numeric	7.5
logical	Also known as a boolean, representing the state of a conditional (question)	TRUE or FALSE
NA	Represents the value of "Not Available" usually seen when imported data has missing values	NA

Data structure	Dimensions	Restrictions
vector	1D	Holds a single data type
matrix	2D	Holds a single data type
array	nD	Holds a single data type
data frame	2D	Holds multiple data types with some restrictions
list	1D (technically)	Holds multiple data types AND structures

Lecture 01: Basics of R and Jupyter Notebooks¶

Student Name: Calvin¶

Student ID: NA¶

0.1.0 About Introduction to R¶

0.1.1 Where is this course headed?¶

0.1.2 How do we get there? Step-by-step.¶

0.1.3 What kind of coding style will we learn?¶

0.2.0 Class Objectives¶

0.3.0 A legend for text format in Jupyter markdown¶

0.4.0 Lecture and data files used in this course¶

0.4.1 Weekly Lecture and skeleton files¶

0.4.2 Live-coding HTML page¶

0.4.3 Post-lecture PDFs and Recordings¶

1.0.0 What is R?¶

1.0.1 Why learn R?¶

1.1.0 Jupyter Notebooks and the R-kernel¶

1.1.1 Why is this class using Jupyter Notebooks?¶

1.2.0 A quick intro to the R environment¶

1.2.1 Packages contain useful functions¶

1.2.2 Useful packages are archived with CRAN and Bioconductor¶

1.3.0 Jupyter notebooks run programming language kernels like R¶

1.3.1 Why would you want to use a Jupyter Notebook?¶

1.4.0 RStudio is an integrated development environment (IDE) for R¶

1.4.1 Why would you want to use R and RStudio?¶

1.5.0 What should I use?¶

1.6.0 Making (Coding) Life Easier¶

1.6.1 Annotate your code with #¶

1.6.2 Naming conventions for files, objects, and functions¶

1.6.3 Best Practices for Writing Scripts¶

1.7.0 Trouble-shooting basics¶

1.7.1 Common errors¶

1.7.2 Beginner Advice¶

1.7.3 Finding answers online¶

1.7.3.1 Asking a question¶

Section 1.0.0 comprehension answer:¶

2.0.0 Using R¶

2.1.0 Basic use of R¶

2.1.1 Basic math and functions¶

2.1.2 Plot equations¶

2.2.0 Functions do the work for us¶

2.2.1 Use the help() function or ? to learn more about functions¶

2.2.2 R evaluates functions by the order of parentheses¶

Section 2.0.0 comprehension answer:¶

3.0.0 A [quick] intro to R's variables, data types, and data structures¶

3.1.0 Assigning variables¶

3.1.1 Blank spaces are usually ignored by the interpreter¶

3.1.1.1 A special case where blankspace matters¶

3.1.2 R calculates from the right side first before (leftward) assignment¶

3.2.0 Data types are the basic building blocks of R¶

3.2.1 Data structures hold single or multiple values¶

3.2.2 Scalars - "One is the loneliest data type"¶

3.2.3 Vectors are like a queue of a single data type¶

3.2.3.1 Coercion changes data from one type to another (if possible)¶

3.2.3.2 What happened to our data??¶

3.2.3.3 Vector contents can be individually named using the name() function¶

3.2.3.4 Use length() to identify the number of elements in a vector¶

3.2.3.5 Use the [ ] indexing notation to extract values¶

3.2.4 Matrices are 2-dimensional containers of a single data type¶

3.2.4.1 A reminder about functions inside functions¶

3.2.4.2 Bracket and parentheses location matters!¶

3.2.4.3 Challenge¶

3.2.4.4 A matrix is a 2D object¶

3.2.4.5 Use [row, column] notation to access portions of a matrix¶

3.2.4.6 Subsetting a matrix returns a vector or matrix¶

3.2.5 Data Frames¶

3.2.5.1 Object classes¶

3.2.5.2 Data frames are groups of vectors disguised as matrices¶

3.2.5.3 Casting a matrix to a data frame using as.data.frame()¶

3.2.5.4 You can access and rename data frame columns (like a header!) with colnames()¶

3.2.5.5 You can't always cast a data frame to a matrix as expected¶

3.2.5.6 Some useful data frame commands (for now)¶

3.2.6 Lists are amorphous bundles strung together with code¶

3.2.6.1 Lists can get complicated.¶

3.2.6.2 Accessing elements from a list with [[ ]] and [ ]¶

3.2.6.3 Use additional levels of [ ] notation to access sub-elements of a list¶

Section 3.0.0 comprehension answer:¶

4.0.0 Special data types and features¶

4.1.0 Factors represent categorical data¶

4.1.1 Use levels() to access factors information¶

4.1.2 Coerce your factor to an integer with as.integer()¶

1.6.1 Annotate your code with `#`¶

2.2.1 Use the `help()` function or `?` to learn more about functions¶

3.2.3.3 Vector contents can be individually named using the `name()` function¶

3.2.3.4 Use `length()` to identify the number of elements in a vector¶

3.2.3.5 Use the `[ ]` indexing notation to extract values¶

3.2.4.5 Use `[row, column]` notation to access portions of a matrix¶

3.2.5.3 Casting a matrix to a data frame using `as.data.frame()`¶

3.2.5.4 You can access and rename data frame columns (like a header!) with `colnames()`¶

3.2.6.2 Accessing elements from a list with `[[ ]]` and `[ ]`¶

3.2.6.3 Use additional levels of `[ ]` notation to access sub-elements of a list¶

4.1.1 Use `levels()` to access factors information¶

4.1.2 Coerce your factor to an integer with `as.integer()`¶

4.1.4 The default behaviour of `data.frame()` creation does not make factors¶

4.1.5 Specify factors during data frame creation with `stringsAsFactors` or `as.factor()`¶

4.1.7 You can specify the order of your factor levels using the `levels` parameter¶

4.1.9 You can relabel your factor values with the `labels` parameter but be careful!¶

4.1.10 The `factor()` function applies a default `level` behaviour before applying the `labels` parameter¶

4.3.0 Using the `apply()` function to perform actions across data structures¶

4.3.1 The `apply()` function will recognize basic functions.¶

4.3.2 Supply a custom function to `apply()`¶